home *** CD-ROM | disk | FTP | other *** search
/ Amiga Inside! / Amiga FD Inside (1995)(Ultramax).iso / berndspd / devtools / precognition / src / library / stringlist.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-16  |  6.2 KB  |  261 lines
  1.  
  2. #include "StringList.h"
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include "amigamem.h"
  6.  
  7.                  /* changed to UBYTE from BYTE -- EDB */
  8. #define QUALFLAG (UBYTE*) -1
  9.  
  10. void StringList_Init( StringList *slist, BOOL Qualify )
  11. {
  12.    slist->Entries    = NULL;
  13.    slist->nEntries   = 0;
  14.  
  15.    if( Qualify )
  16.        slist->Qualifiers = QUALFLAG;
  17.    else
  18.        slist->Qualifiers =  0;
  19. }
  20.  
  21. #ifdef STRINGLIST_VERBOSE
  22.  
  23. void dump_StringList( StringList *list )
  24. {
  25.    int i;
  26.  
  27.    printf( "dump_StringList: nEntries=%d\n", list->nEntries );
  28.  
  29.    for( i = 0; i < list->nEntries; i++ )
  30.       printf( "%d (%d), %s\n",
  31.          i, list->Entries[i], list->Entries[i] );
  32. }
  33.  
  34. #endif
  35.  
  36. void StringList_CleanUp( StringList *slist )
  37. {
  38.    StringList_DeleteAllStrings( slist );
  39. }
  40.  
  41. BOOL StringList_AddString( StringList *slist,
  42.                            char       *string,
  43.                            BYTE        qualifiers )
  44. {
  45.    char **new_entries;
  46.    BYTE  *new_quals;
  47.    char *new_entry;
  48.    USHORT n, i;
  49.  
  50.    n = slist->nEntries + 1;
  51.    /*printf( "about to malloc\n" );*/
  52.    if( new_entries = (char **)Amalloc( sizeof( char* ) * n ) )
  53.    {
  54.       /*printf("copying to new array...\n");*/
  55.       for( i = 0; i < slist->nEntries; i++ )
  56.          new_entries[i] = slist->Entries[i];
  57.  
  58.       /*printf( "StringList_AddString: adding new string, n=%d, string=\"%s\"\n", n, string);*/
  59.       new_entries[n-1] = new_entry = Astrdup( string );
  60.  
  61.       if( slist->Qualifiers )
  62.       {
  63.          /*printf("doing qualifiers...\n");*/
  64.          if( new_quals = (BYTE *)Amalloc( sizeof( BYTE ) * n ) )
  65.          {
  66.             for( i = 0; i < slist->nEntries; i++ )
  67.                new_quals[i] = slist->Qualifiers[i];
  68.  
  69.             new_quals[n-1] = qualifiers;
  70.             /*printf( "finished qualifiers!\n" );*/
  71.  
  72.             Afree( slist->Entries );
  73.             if( slist->Qualifiers != QUALFLAG )
  74.               Afree( slist->Qualifiers );
  75.             slist->Entries    = new_entries;
  76.             slist->nEntries++;
  77.             slist->Qualifiers = new_quals;
  78.  
  79.             /*printf( "StringList_AddString : DONE!\n" );*/
  80.             return TRUE;
  81.          }
  82.          else
  83.          {
  84.             /*printf( "couldn't allocate qualifiers\n" );*/
  85.             Afree( new_entry );
  86.             Afree( new_entries );
  87.             return FALSE;
  88.          }
  89.       }
  90.       else
  91.       {
  92.          Afree( slist->Entries );
  93.          slist->Entries = new_entries;
  94.          slist->nEntries++;
  95.          return TRUE;
  96.       }
  97.    }
  98.    else
  99.    {
  100.       ; /*printf( "StringList_AddString: Amalloc failed.\n" );*/
  101.    }
  102.    return FALSE;
  103. }
  104.  
  105. BOOL StringList_DeleteString( StringList *slist, USHORT n )
  106. {
  107.    USHORT i;
  108.  
  109.  
  110.    if( n >= slist->nEntries ) return FALSE;
  111.  
  112. /*DUMPWAIT( "StringList_DeleteString: before Afree\n" );*/
  113.    Afree( slist->Entries[n] );
  114. /*DUMPWAIT( "StringList_DeleteString: after Afree\n" );*/
  115.  
  116.    for( i = n; i < slist->nEntries-1; i++ )
  117.    {
  118.       slist->Entries[i] = slist->Entries[i+1];
  119.       if( slist->Qualifiers )
  120.          slist->Qualifiers[i] = slist->Qualifiers[i+1];
  121.    }
  122.    slist->nEntries--;
  123.  
  124.    slist->Entries = (char **)Arealloc( slist->Entries,
  125.                                        sizeof(char*)*slist->nEntries );
  126.    if( slist->Qualifiers )
  127.    {
  128.       if( slist->nEntries )
  129.          slist->Qualifiers = (BYTE *)Arealloc( slist->Qualifiers,
  130.                                                sizeof( BYTE ) * slist->nEntries );
  131.       else
  132.          slist->Qualifiers = QUALFLAG;
  133.    }
  134.  
  135.  /*DUMPWAIT( "end StringList_DeleteString\n" );*/
  136.  
  137.    return TRUE;
  138. }
  139.  
  140. BOOL StringList_DeleteAllStrings( StringList *slist )
  141. {
  142.    int i;
  143.  
  144.    for( i = 0; i < slist->nEntries; i++ )
  145.    {
  146.       Afree( slist->Entries[i] );
  147.    }
  148.  
  149.    if( slist->Entries )
  150.    {
  151.       Afree( slist->Entries );
  152.       slist->Entries=NULL;
  153.    }
  154.    if( ( slist->Qualifiers ) && ( slist->Qualifiers != QUALFLAG ) )
  155.    {
  156.       Afree( slist->Qualifiers );
  157.       slist->Qualifiers = QUALFLAG;
  158.    }
  159.    slist->nEntries = 0;
  160.    return TRUE;
  161. }
  162.  
  163. void StringList_Sort( StringList *slist )
  164. {
  165.    USHORT j, i, i1;
  166.    char *e_i, *e_i1;
  167.    BYTE q;
  168.  
  169.    for( j = 0; j < slist->nEntries-1; j++ )
  170.    {
  171.       for( i = j; i < slist->nEntries-1; i++ )
  172.       {
  173.          i1   = i+1;
  174.          e_i  = slist->Entries[i];
  175.          e_i1 = slist->Entries[i1];
  176.  
  177.          if( strcmp( e_i, e_i1 ) > 0 )
  178.          {
  179.             slist->Entries[i]  = e_i1;
  180.             slist->Entries[i1] = e_i;
  181.  
  182.             if( slist->Qualifiers )
  183.             {
  184.                q = slist->Qualifiers[i];
  185.                slist->Qualifiers[i]  = slist->Qualifiers[i1];
  186.                slist->Qualifiers[i1] = q;
  187.             }
  188.          }
  189.       }
  190.    }
  191. }
  192.  
  193.  
  194. BOOL StringList_Dup( StringList *source, StringList *target )
  195. {
  196.    USHORT i, j, n;
  197.  
  198.    if( ( n = source->nEntries ) > 0 )
  199.    {
  200.       target->nEntries = n;
  201.  
  202.       if( target->Entries = (char **)Amalloc( n * sizeof( char** ) ) )
  203.       {
  204.          for( i = 0; i < n; i++ )
  205.          {
  206.             if( !( target->Entries[i] = Astrdup( source->Entries[i] ) ) )
  207.             {
  208.                /* release memory already allocated. */
  209.                for( j = 0; j < i; j++ )
  210.                   Afree( target->Entries[j] );
  211.                Afree( target->Entries );
  212.  
  213.                return FALSE;
  214.             }
  215.          }
  216.  
  217.          if( source->Qualifiers )
  218.          {
  219.             if( target->Qualifiers = (UBYTE *)Amalloc( n * sizeof( UBYTE ) ) )
  220.             {
  221.                for( i = 0; i < n; i++ )
  222.                   target->Qualifiers[i] = source->Qualifiers[i];
  223.             }
  224.             else
  225.             {
  226.                /* release memory already allocated. */
  227.                StringList_CleanUp(target);
  228.                return FALSE;
  229.             }
  230.          }
  231.          return TRUE;
  232.  
  233.       }
  234.    }
  235.    else
  236.    {   /* changed from StringList_Init( target, (BOOL)( source->Qualifiers ) ); -- EDB */
  237.       if( source->Qualifiers == NULL )
  238.          StringList_Init( target, FALSE );
  239.       else
  240.          StringList_Init( target, TRUE );
  241.  
  242.       return TRUE;
  243.    }
  244. }
  245.  
  246. BOOL StringList_AddStrings( StringList  *slist,
  247.                             char       **strings,
  248.                             BYTE        *qualifiers )
  249. {
  250.    USHORT i;
  251.  
  252.    for( i = 0; strings[i] != NULL; i++ )
  253.    {
  254.       if( ! StringList_AddString( slist, strings[i],
  255.                            ( qualifiers ? qualifiers[i] : 0) ) )
  256.          return FALSE;
  257.    }
  258.  
  259.    return TRUE;
  260. }
  261.